It's not necessary and doing an implicit search after typer does not
sound like a good idea.

Previously, the array literal argument `{ "foo", "bar" }` was typed as
an `Array["foo" | "bar"]`, which is not a subtype of the corresponding
parameter type (`Array[String]`). This lead to a crash when forcing
the annotation. This is a serious problem because in Java 9+, JFrame
contains such an annotation, therefore this affects basically any code
using Swing/AWT.

Similary an empty array `{}` was always typed as `Array[Object]` which
does not always match the parameter type, this one is trickier to fix
since the serialized annotation does not keep track of the element type
of an empty array and we don't want to force the serialization at this
point, so we use a WildcardType.

We can't properly type annotation arguments which are empty array
literals because we would need the corresponding parameter type which
would require forcing the annotation constructor early. The previous
commit worked around this by using `WildcardType` as the element type
but that's a hack. Instead, we can fix the problem by always storing
annotation arguments as untyped trees and using `applyOverloaded` to
type them when the annotation tree is forced. This requires some
refactoring to make `applyOverloaded` work both with typed and untyped
arguments (the variants are now accessible using `untpd.applyOverloaded`
and `tpd.applyOverloaded`).

(the abstract `def FunProto` in Trees that gets implemented by
forwarding in untpd/tpd sounds like a good candidate for `export`,
except we can't export a class constructor)

Already taken care of by the `typeParamCount(tr) == targs.length`
filtering done above.